<template>
  <view class="container">
    <!-- 手机号获取页面 -->
    <PhonePage 
      v-if="currentPage === 'phone'"
      :selected-version="selectedVersion"
      :has-token="hasToken"
      @select-version="selectVersion"
      @get-phone-number="getPhoneNumber"
      @start-test="startTest"
      @change-page="changePage"
    />
    
    <!-- MBTI测试页面 -->
    <TestPage 
      v-else-if="currentPage === 'test'"
      :current-question-index="currentQuestionIndex"
      @get-phone-number="getPhoneNumber"
      :questions="questions"
      :selected-options="selectedOptions"
      :has-token="hasToken"
      @go-back="goBack"
      :current-question-text="currentQuestionText"
      :current-question-options="currentQuestionOptions"
      @select-option="selectOption"
      @submit-test="submitTest"
      @change-page="changePage"
      @close-test="closeTest"
    />
    
    <!-- 结果报告页面 -->
    <ResultPage 
      v-else-if="currentPage === 'result'"
      :order-id="currentOrderId"
      :test-id="currentTestId"
      :price="price"
      @show-payment="showPayment"
      @share-report="shareReport"
      @restart-test="restartTest"
      @change-view="changeView"
    />

    <!-- 订单列表页面 -->
    <MyOrderPage 
      v-else-if="currentPage === 'order'"
      @go-back="goBackToResult"
      @view-report="viewReport"
    />
    
    <!-- 支付页面 -->
    <PaymentPage 
      v-else-if="currentPage === 'payment'"
      :selected-payment-method="selectedPaymentMethod"
      :price="price"
      :test-result-id="testResultId"
      :user-id="userId"
      @select-payment-method="selectPaymentMethod"
      @confirm-payment="handleConfirmPayment"
      @cancel-payment="cancelPayment"
    />
    
    <!-- 等待页面 -->
    <view v-else-if="currentPage === 'loading'" class="loading-page">
      <view class="loading-content">
        <view class="loading-spinner"></view>
        <text class="loading-text">正在生成您的专属报告...</text>
        <text class="loading-subtext">这可能需要几秒钟时间</text>
      </view>
    </view>
    
    <!-- 在线客服按钮 -->
    <button class="customer-service-btn" open-type="contact">客服</button>
  </view>
</template>

<script>
// 导入题库文件
//import { testQuestions, getQuestionsByType } from '@/static/js/test-questions.js';
// 导入api接口
import api from '@/api/api.js';

// 导入组件
import PhonePage from '../../components/mbti/PhonePage.vue';
import MyOrderPage from '../../components/mbti/MyOrderPage.vue';
import TestPage from '../../components/mbti/TestPage.vue';
import ResultPage from '../../components/mbti/ResultPage.vue';
import PaymentPage from '../../components/mbti/PaymentPage.vue';

export default {
  components: {
    MyOrderPage,
    PhonePage,
    TestPage,
    ResultPage,
    PaymentPage
  },
  data() {
    return {
      currentPage: 'phone', // phone, test, result, payment, orders
      phoneNumber: '',
      showManualInput: false, // 控制是否显示手动输入
      currentQuestionIndex: 0,
      selectedOptions: [],
      isPaid: false,
      selectedPaymentMethod: '',
      mbtiType: 'INTJ',
      selectedVersion: 'standard', // 默认选择标准版
      isLoggedIn: false, // 添加响应式登录状态
      
      // MBTI问题数据 - 动态获取
      questions: [],
      
      // 测试结果相关数据
      testResultId: null, // 存储测试结果ID
      userId: null, // 存储用户ID
      testTypeFromResult: null, // 存储从getTestResult接口返回的testType值
      currentOrderId: null, // 存储当前订单ID
      currentTestId: null,
      
      // 价格信息
      price: 0, // 商品价格
      
      // 结果数据
      personalityTraits: "",
      personalityTags: [],
      careerAdvice: "",
      recommendedCareers: [],
      relationshipTips: "",
      fullRelationshipTips: "",
      growthAdvice: "",
      fullGrowthAdvice: "",
      famousPeople: [],
      
      // 基础画像数据
      baseProfile: {
        mbtiType: "",           // MBTI类型
        personalityImage: "",   // 人格图片描述
        eiRatio: "",            // E/I占比
        snRatio: "",            // S/N占比
        tfRatio: "",            // T/F占比
        jpRatio: "",            // J/P占比
        personalityIndex: "",   // 人格指数
        personalityIntro: "",   // 人格字母介绍
        personalityTraits: "",  // 人格特点
        rarity: "",             // 人格稀有度
        representativeFigures: "" // 代表人物
      },
      
      // MBTI计算计数器
      counts: { E: 0, I: 0, S: 0, N: 0, T: 0, F: 0, J: 0, P: 0 }
    };
  },
  
  computed: {
    isValidPhone() {
      return /^1[3-9]\d{9}$/.test(this.phoneNumber);
    },
    
    currentQuestion() {
      return this.questions[this.currentQuestionIndex];
    },
    
    progressWidth() {
      return `${((this.currentQuestionIndex + 1) / this.questions.length) * 100}%`;
    },
    
    // 检测是否有登录token
    hasToken() {
      // 使用响应式数据 + 本地存储双重检查
      const hasTokenInStorage = !!uni.getStorageSync('MH_TOKEN');
      console.log('hasToken计算属性被调用，本地存储token:', hasTokenInStorage, '响应式状态:', this.isLoggedIn);
      return this.isLoggedIn || hasTokenInStorage;
    },
    
    // 获取当前题目文本
    currentQuestionText() {
      if (this.questions && this.questions[this.currentQuestionIndex]) {
        return this.questions[this.currentQuestionIndex].text;
      }
      return '';
    },
    
    // 获取当前题目选项
    currentQuestionOptions() {
      if (this.questions && this.questions[this.currentQuestionIndex]) {
        return this.questions[this.currentQuestionIndex].options || [];
      }
      return [];
    }
  },
  
  watch: {
    currentQuestionIndex: {
      handler(newIndex, oldIndex) {
        console.log(`题目索引变化: ${oldIndex} -> ${newIndex}`);
        // 可以在这里添加其他逻辑
      },
      immediate: true
    },
    questions: {
      handler(newQuestions) {
        if (newQuestions && newQuestions.length > 0) {
          console.log('题目数据更新，长度:', newQuestions.length);
          // 确保选项数组长度与题目数量一致
          if (this.selectedOptions.length !== newQuestions.length) {
            this.selectedOptions = new Array(newQuestions.length).fill(undefined);
          }
        }
      },
      immediate: true
    }
  },
  
  created() {
    // 页面创建时动态加载题目
    this.loadQuestions();
    
    // 价格信息会在获取测试结果后根据实际的testType值来获取
    // this.getPriceInfo();
    
    // 检查初始登录状态
    const hasToken = !!uni.getStorageSync('MH_TOKEN');
    this.isLoggedIn = hasToken;
    console.log('页面创建时检查登录状态:', hasToken);
  },
  
  onLoad(options) {
    // 处理页面跳转时传递的参数
    if (options && options.currentPage) {
      this.currentPage = options.currentPage;
    }
  },

  onShareAppMessage(e) {
    console.log('onShareAppMessage', this.mbtiType, e);
   var mbtitype=  e.target.dataset.mbtitype;
   return {
      title: '我的MBTI是：' + mbtitype + '，快来看看你的MBTI是哪一个呢',
      path: '/pages/share/shareMbti?mbtitype=' + mbtitype,
      //https://hongcat-beta.oss-cn-chengdu.aliyuncs.com/share_imgs/share_ENFJ.png
      imageUrl: "https://hongcat-beta.oss-cn-chengdu.aliyuncs.com/share_imgs/share_" + mbtitype + ".png"
    }
  },
  
  methods: {
    // 动态加载题目
    loadQuestions() {
      try {
        // 调用RandomQuestions接口获取题目
        const requestData = {
          count: this.selectedVersion === 'standard' ? 48 : 
                 this.selectedVersion === 'professional' ? 96 : 
                 this.selectedVersion === 'complete' ? 200 : 48
        };
        
        this.$api.RandomQuestions(requestData).then(res => {
          console.log('获取题目成功:', res);
          if (res.data && res.data.code === 200 && res.data.data) {
            // 将返回的数据转换为题目格式
            const questions = res.data.data.map(item => ({
              id: item.id,
              text: item.text,
              options: [
                { text: item.optionA, score: item.scoreIfA },
                { text: item.optionB, score: item.scoreIfB }
              ],
              dimension: item.dimension
            }));
            
            if (questions && questions.length > 0) {
              // 添加延迟确保数据正确更新
              setTimeout(() => {
                this.questions = questions;
                // 重置题目索引和选项
                this.currentQuestionIndex = 0;
                this.selectedOptions = new Array(questions.length).fill(undefined);
                console.log(`成功加载${this.selectedVersion}版本题目，共${questions.length}题`);
              }, 10);
            } else {
              console.warn('未获取到题目，使用默认题目');
            }
          } else {
            console.warn('接口返回数据格式不正确，使用默认题目');
          }
        }).catch(error => {
          console.error('加载题目失败:', error);
          uni.showToast({
            title: '加载题目失败',
            icon: 'none'
          });
        });
      } catch (error) {
        console.error('加载题目异常:', error);
        uni.showToast({
          title: '加载题目异常',
          icon: 'none'
        });
        
      }
    },
    
    // 切换输入方式
    toggleInputMethod() {
      this.showManualInput = !this.showManualInput;
      // 切换时清空已输入的手机号
      if (!this.showManualInput) {
        this.phoneNumber = '';
      }
    },
    
    // 微信获取手机号
    getPhoneNumber(e,form) {
      console.log('微信获取手机号', e, form);
      uni.getProvider({
        service: 'oauth',
        success: (res) => {
          console.log('微信登录', res);
          if (~res.provider.indexOf("weixin")) {
            uni.login({
              provider: "weixin",
              success: (loginRes) => {
                // this.wxLoginForm.code = loginRes.code
                uni.getUserInfo({
                  success: (infoRes) => {
                    console.log('微信登录2', infoRes);
                    this.$api.getOpenInfo({
                      code: loginRes.code,
                      encryptedData: infoRes.encryptedData,
                      iv: infoRes.iv
                    }).then(res => {
                      console.log('获取openid成功', res, res.data.data.openid);
                      this.wxLoginFun(e, res.data.data.openid, infoRes.rawData,form);
                    }).catch(err => {
                      console.error('获取openid失败', err);
                      uni.showToast({
                        title: '获取openid失败',
                        icon: 'none'
                      });
                    });
                  }
                })
              }
            })
          }
        }
      })
      
      console.log('微信获取手机号', e, this.$api);
    },
    getOpenInfo(){

    },
    wxLoginFun(e,openid,rawData,form){
      console.log("openid:::",openid);
      console.log("rawData:::",rawData);
         if (e.detail.errMsg === 'getPhoneNumber:ok') {
        // 这里应该调用后端接口解密手机号
        // 实际开发中需要将 e.detail.encryptedData 和 e.detail.iv 发送到后端解密
        this.$api.wxLogin({
          code: e.detail.code,
          openId: openid,
          rawData:rawData,
          encryptedData: e.detail.encryptedData,
          iv: e.detail.iv,
        }).then(res => {
          console.log('解密成功', res);
          
          //存储手机号
          uni.setStorageSync('phoneNumber', res.data.data.phoneNumber);
          uni.setStorageSync('openId', openid);
          
          // 存储token到store
          this.$store.commit('SET_USERTOKEN', {
            token: res.data.data.token,
            isRemember: true
          });
          
          // 存储token到本地存储，用于hasToken计算属性检测
          uni.setStorageSync('MH_TOKEN', res.data.data.token);
          
          // 更新响应式登录状态
          this.isLoggedIn = true;
          
          // 调试：检查token是否正确存储
          console.log('Token已存储到本地存储:', res.data.data.token);
          console.log('检查本地存储中的token:', uni.getStorageSync('MH_TOKEN'));
          console.log('hasToken计算属性值:', this.hasToken);
          console.log('isLoggedIn状态已更新为:', this.isLoggedIn);

          // 存储用户信息到store
          this.$store.commit('SET_USERINFO', res.data.data.user);
          
          uni.showToast({
            title: '登录成功',
            icon: 'success'
          });

          // 再次检查状态
          setTimeout(() => {
            console.log('登录成功后的hasToken值:', this.hasToken);
            console.log('登录成功后的isLoggedIn值:', this.isLoggedIn);
          }, 100);
          if (form&&form=="test") {
            debugger;
            this.submitTest();
          }
          // 登录成功后不自动跳转，让用户手动点击开始探索
          // setTimeout(() => {
          //   this.startTest();
          // }, 1000);
        }).catch(err => {
          console.error('登录失败', err);
          uni.showToast({
            title: '登录失败',
            icon: 'none'
          });
        });
      } else {
        uni.showToast({
          title: '获取失败',
          icon: 'none'
        });
      }
    },
    
    // 选择测试版本
    selectVersion(version) {
      this.selectedVersion = version;
      console.log('选择版本:', version);
      
      // 重新加载对应版本的题目
      this.loadQuestions();
      
      // 重置测试状态
      this.currentQuestionIndex = 0;
      this.selectedOptions = [];
    },
    
    getOptionLetter(index) {
      return String.fromCharCode(65 + index); // A, B, C, D...
    },
    
    getMBTITypeName(type) {
      const typeNames = {
        'INTJ': '建筑师',
        'INTP': '逻辑学家',
        'ENTJ': '指挥官',
        'ENTP': '辩论家',
        'INFJ': '提倡者',
        'INFP': '调停者',
        'ENFJ': '主人公',
        'ENFP': '竞选者',
        'ISTJ': '物流师',
        'ISFJ': '守护者',
        'ESTJ': '总经理',
        'ESFJ': '执政官',
        'ISTP': '鉴赏家',
        'ISFP': '冒险家',
        'ESTP': '企业家',
        'ESFP': '表演者'
      };
      return typeNames[type] || '未知类型';
    },
    
    getCompatibleTypes(type) {
      const compatibility = {
        'INTJ': 'ENFP, ENTP',
        'INTP': 'ENTJ, ENFJ',
        'ENTJ': 'INTP, INFP',
        'ENTP': 'INTJ, INFJ',
        'INFJ': 'ENFP, ENTJ',
        'INFP': 'ENFJ, ENTJ',
        'ENFJ': 'INFP, ISFP',
        'ENFP': 'INFJ, INTJ',
        'ISTJ': 'ESFP, ESTP',
        'ISFJ': 'ESFP, ESTP',
        'ESTJ': 'ISFP, ISTP',
        'ESFJ': 'ISFP, ISTP',
        'ISTP': 'ESFJ, ESTJ',
        'ISFP': 'ESFJ, ESTJ',
        'ESTP': 'ISFJ, ISTJ',
        'ESFP': 'ISFJ, ISTJ'
      };
      return compatibility[type] || '待探索';
    },
    
    startTest() {
   
      // 确保题目已加载
      console.log("qaa",this.questions);
      if (!this.questions || this.questions.length === 0) {
           console.log('开始测试111');
        console.warn('题目未加载，尝试重新加载');
        this.loadQuestions();
        
        // 等待题目加载完成后再次尝试开始测试
        setTimeout(() => {
             console.log('开始测试1112222');
          if (this.questions && this.questions.length > 0) {
            this.startTest();
          } else {
            uni.showToast({
              title: '题目加载失败',
              icon: 'none'
            });
          }
        }, 500);
        return;
      }
      console.log("token", this.hasToken,this.isValidPhone);
      // 如果用户已登录，直接开始测试
      // if (this.hasToken) {
      //   this.currentPage = 'test';
      //   return;
      // }
      
      // // 如果用户未登录，验证手机号
      // if (this.isValidPhone) {
      //   this.currentPage = 'test';
      //   // 这里可以调用后端接口保存手机号
      //   console.log('手机号:', this.phoneNumber);
      // }
       this.currentPage = 'test';
      return;
    },
    
    goBack() {
      if (this.currentPage === 'test' && this.currentQuestionIndex === 0) {
        this.currentPage = 'phone';
      } else if (this.currentPage === 'test') {
        this.prevQuestion();
      }
    },
    
    selectOption(optionIndex) {
      this.$set(this.selectedOptions, this.currentQuestionIndex, optionIndex);
      
      // 自动跳转到下一题，添加防抖机制
      setTimeout(() => {
        if (this.currentQuestionIndex < this.questions.length - 1) {
          this.currentQuestionIndex++;
        }
      }, 50); // 延迟50毫秒确保数据更新完成
    },
    
    submitTest() {
      // 检查是否所有题目都已回答
      const allAnswered = this.selectedOptions.every(option => option !== undefined);
      if (allAnswered) {
        // 计算MBTI结果
        this.calculateMBTI();
        
        // 直接调用createTestResult接口
        this.callCreateTestResult();
          // 跳转到结果页面
          //this.currentPage = 'result';
        
        
      } else {
        uni.showToast({
          title: '请回答所有题目',
          icon: 'none'
        });
      }
    },
    
    // 计算MBTI类型
    calculateMBTI() {
      // MBTI计算逻辑
      let type = '';
      // 重置计数器
      this.counts = { E: 0, I: 0, S: 0, N: 0, T: 0, F: 0, J: 0, P: 0 };
      
      // 遍历所有题目和用户选择
      console.log('开始计算MBTI类型...',this.questions);
      this.questions.forEach((question, index) => {
        const userSelection = this.selectedOptions[index];
        if (userSelection !== undefined && question.options && question.options[userSelection]) {
          const selectedOption = question.options[userSelection];
          const score = selectedOption.score || selectedOption.text.charAt(0); // 兼容新旧格式
          // debugger;
          // 根据题目维度增加对应计数
          if (question.dimension) {
            // 新格式：有dimension字段
            if (question.dimension === 'E/I') {
              this.counts[score]++;
            } else if (question.dimension === 'S/N') {
              this.counts[score]++;
            } else if (question.dimension === 'T/F') {
              this.counts[score]++;
            } else if (question.dimension === 'J/P') {
              this.counts[score]++;
            }
          } else {
            // 兼容旧格式：根据题目索引推断维度
            if (index % 4 === 0) { // EI维度
              this.counts[score]++;
            } else if (index % 4 === 1 || index % 4 === 2) { // SN维度
              this.counts[score]++;
            } else if (index % 4 === 3) { // TF维度
              this.counts[score]++;
            }
          }
        }
      });
      
      // 计算每个维度的结果
      type += this.counts.E >= this.counts.I ? 'E' : 'I';
      type += this.counts.S >= this.counts.N ? 'S' : 'N';
      type += this.counts.T >= this.counts.F ? 'T' : 'F';
      type += this.counts.J >= this.counts.P ? 'J' : 'P';
      
      this.mbtiType = type || 'INTJ'; // 默认值
      
      console.log('MBTI计算结果:', this.mbtiType);
      console.log('各维度计数:', this.counts);
    },
    
    // 调用createTestResult接口
    callCreateTestResult() {
      // 构建测试值对象
      const testValue = this.counts;

      console.log('测试值对象:', testValue);
      const requestData = {
        testResult: this.mbtiType,
        testValue: JSON.stringify(testValue),
        testType: `mbti::${this.selectedVersion}`
      };
      console.log('提交测试结果数据:', requestData);
      this.currentPage = 'loading';
      api.createTestResult(requestData).then(res => {
        console.log('测试结果保存成功:', res);
        if (res.data && res.data.code === 200) {
          this.currentTestId = res.data.data.id;
          this.testResultId = res.data.data.id;
          this.userId = res.data.data.userId;
          
          // uni.showToast({
          //   title: '已提交测试结果，请等待...',
          //   icon: 'success',
          //   duration: 1500
          // });
         
          this.gotoResultPage();
        } else {
          uni.showToast({
            title: res.data?.msg || '保存失败',
            icon: 'none'
          });
        }
      }).catch(err => {
        console.error('保存测试结果失败:', err);
        uni.showToast({
          title: '网络错误，保存失败',
          icon: 'none'
        });
      });
    },
    gotoResultPage() {
      // 先跳转到等待页面
      this.currentPage = 'loading';
      
      // 开始轮询请求测试结果
      this.pollTestResult();
    },
    
    // 轮询获取测试结果
    pollTestResult() {
      // 定时器，每隔3秒请求一次接口
      const pollInterval = setInterval(() => {
        this.$api.getTestResultInfo({TestId: this.testResultId}).then(res => {
          // 检查响应数据
          if (res.data && res.data.code === 200) {
            // 清除定时器
            clearInterval(pollInterval);
            
            // 获取价格信息，使用testType字段的值
            if (res.data.data.testType) {
              this.getPriceInfo(res.data.data.testType);
            }
            

            // 跳转到结果页面
            this.currentPage = 'result';
          }
          // 如果code不为200，继续轮询
        }).catch(err => {
          console.error('轮询获取测试结果失败:', err);
          // 继续轮询，不中断
        });
      }, 3000); // 每3秒请求一次
      
    },
    nextQuestion() {
      if (this.selectedOptions[this.currentQuestionIndex] !== undefined) {
        if (this.currentQuestionIndex < this.questions.length - 1) {
          this.currentQuestionIndex++;
        } else {
          // 提交测试，计算结果
          this.calculateMBTI();
          this.callCreateTestResult();
          this.currentPage = 'result';
        }
      }
    },
    
    prevQuestion() {
      if (this.currentQuestionIndex > 0) {
        this.currentQuestionIndex--;
      }
    },
    
    showPayment(data) {
      this.testResultId = data.id;
      // this.userId = data.userId;
      this.testType = data.testType;
      this.price = data.price;
      console.log('Index.vue showPayment method called');
      console.log('Test result ID:', this.testResultId);
      console.log('User ID:', this.userId);
      this.currentPage = 'payment';
      
    },
    
    selectPaymentMethod(method) {
      console.log('Index.vue selectPaymentMethod method called with:', method);
      this.selectedPaymentMethod = method;
    },
    
    cancelPayment() {
      this.currentPage = 'result';
      this.selectedPaymentMethod = '';
    },
    
    // 添加 handleConfirmPayment 方法来处理确认支付事件
    handleConfirmPayment() {
      console.log('Index.vue handleConfirmPayment method called');
      console.log('Selected payment method:', this.selectedPaymentMethod);
      console.log('Test result ID:', this.testResultId);
      console.log('User ID:', this.userId);
      // 检查是否有测试结果ID和用户ID
      // if (!this.testResultId || !this.userId) {
      //   uni.showToast({
      //     title: '测试信息不完整，请重新测试',
      //     icon: 'none'
      //   });
      //   return;
      // }
      
      // 检查是否选择了支付方式
      if (!this.selectedPaymentMethod) {
        uni.showToast({
          title: '请选择支付方式',
          icon: 'none'
        });
        return;
      }
      
      // 调用CreatePay接口
      this.createPayment();
    },
    
    // 创建支付订单
    createPayment() {
      console.log('Creating payment, testResultId:', this.testResultId, 'userId:', this.userId);
      // 构建请求数据
      const requestData = {
        testId: this.testResultId,
        testType: this.getTestTypeValue() // 从getTestResult接口返回的testType中提取::之后的值
      };
      
      console.log('创建支付订单数据:', requestData);
      
      // 调用CreatePay接口
      this.$api.CreatePay(requestData).then(res => {
        console.log('创建订单成功:', res);
        if (res.data && res.data.code === 200) {
          const payData = res.data.data;
          
          // 调用微信支付
          this.requestPayment(payData);
        } else {
          uni.showToast({
            title: res.data?.msg || '创建订单失败',
            icon: 'none'
          });
        }
      }).catch(err => {
        console.error('创建订单失败:', err);
        uni.showToast({
          title: '网络错误，创建订单失败',
          icon: 'none'
        });
      });
    },
    
    // 从testType中提取::之后的值
    getTestTypeValue() {
      console.log('Getting test type value, testTypeFromResult:', this.testTypeFromResult);
      // 如果testType包含::，则取::之后的部分
      if (this.testTypeFromResult && this.testTypeFromResult.includes("::")) {
        const value = this.testTypeFromResult.split("::")[1];
        console.log('Extracted test type value:', value);
        return value;
      }
      // 如果没有::，则直接返回原值
      console.log('Returning default test type value:', this.testTypeFromResult || "standard");
      return this.testTypeFromResult || "standard";
    },
    
    // 发起微信支付
    requestPayment(payData) {
      uni.requestPayment({
        timeStamp: payData.timeStamp,
        nonceStr: payData.nonceStr,
        package: payData.package,
        signType: payData.signType,
        paySign: payData.paySign,
        success: (res) => {
          console.log('支付成功:', res);
          this.isPaid = true;
          this.currentPage = 'result';
          uni.showToast({
            title: '支付成功',
            icon: 'success'
          });
        },
        fail: (err) => {
          console.error('支付失败:', err);
          uni.showToast({
            title: '支付已取消',
            icon: 'none'
          });
        }
      });
    },
    
    shareReport(mbtiType) {
      // 分享报告功能
      // 如果没有传入mbtiType参数，则使用this.mbtiType
      const type = mbtiType || this.mbtiType;
      const mbtiName = this.getMBTITypeName(type);
      
      // 创建分享内容
      const shareContent = `我刚完成了MBTI性格测试，我的性格类型是${type} - ${mbtiName}！快来测测你的性格类型吧！`;
      
      // 使用uni.shareWithSystem分享到系统
      uni.shareWithSystem({
        type: 0,
        title: 'MBTI性格测试',
        summary: shareContent,
        success: function (res) {
          console.log('分享成功');
          uni.showToast({
            title: '分享成功',
            icon: 'success'
          });
        },
        fail: function (err) {
          console.log('分享失败:', err);
          // 分享失败时复制到剪贴板
          uni.setClipboardData({
            data: shareContent,
            success: function () {
              uni.showToast({
                title: '内容已复制到剪贴板',
                icon: 'none'
              });
            }
          });
        }
      });
    },
    
    restartTest() {
      this.currentPage = 'phone';
      this.phoneNumber = '';
      this.currentQuestionIndex = 0;
      this.selectedOptions = [];
      this.isPaid = false;
      this.selectedPaymentMethod = '';
    },
    changeView(data){
      this.currentPage = data;
    },
    
    changePage(pageName) {
      this.currentPage = pageName;
    },
    
    goBackToResult() {
      this.currentPage = 'phone';
    },
    
    // 查看报告
    viewReport(order) {
      // 切换到结果页面
      this.currentPage = 'result';
      // 设置当前订单ID
      // this.currentOrderId = order.id;
      this.currentTestId = order.id;

      // 可以在这里添加其他逻辑，例如加载特定的报告数据
      console.log('查看报告:', order);
    },
    
    closeTest() {
      // 关闭测试，返回到手机号页面
      this.currentPage = 'phone';
      // 重置测试状态
      this.currentQuestionIndex = 0;
      this.selectedOptions = [];
    },
    
    // 获取价格信息
    getPriceInfo(testType) {
      // 如果没有传入testType参数，则使用默认值
      let type = testType || "standard";
      
      // 如果testType包含::，则取::之后的部分
      if (type.includes("::")) {
        type = type.split("::")[1];
      }
      
      // 调用接口获取价格
      this.$api.getPrice({testType: type}).then(res => {
        console.log('获取价格成功:', res);
        if (res.data && res.data.code === 200) {
          // 更新价格信息
          console.log('获取价格成功:', res.data.data.Prcie);
          this.price = res.data.data.Prcie;
        } else {
          console.error('获取价格失败:', res.data?.msg || '未知错误');
        }
      }).catch(err => {
        console.error('获取价格接口调用失败:', err);
      });
    },
  }
};
</script>

<style scoped>
.container {
  min-height: 100vh;
  background-image: url('https://hongcat-beta.oss-cn-chengdu.aliyuncs.com/bg.png');
  background-size: cover;
  background-position: center;
  background-repeat: no-repeat;
  background-attachment: fixed;
}

.container::before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: transparent;
  z-index: 1;
}

.page {
  padding: 40rpx;
  min-height: 100vh;
  box-sizing: border-box;
  position: relative;
  z-index: 2;
}

/* 等待页面样式 */
.loading-page {
  display: flex;
  justify-content: center;
  align-items: center;
  height: 100vh;
  background: rgba(0, 0, 0, 0.7);
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  z-index: 999;
}

.loading-content {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  padding: 40rpx;
  background: white;
  border-radius: 20rpx;
  box-shadow: 0 10rpx 30rpx rgba(0, 0, 0, 0.2);
}

.loading-spinner {
  width: 80rpx;
  height: 80rpx;
  border: 8rpx solid #f3f3f3;
  border-top: 8rpx solid #ff6b6b;
  border-radius: 50%;
  animation: spin 1s linear infinite;
  margin-bottom: 30rpx;
}

@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

.loading-text {
  font-size: 32rpx;
  font-weight: bold;
  color: #333;
  margin-bottom: 20rpx;
  text-align: center;
}

.loading-subtext {
  font-size: 24rpx;
  color: #666;
  text-align: center;
}

/* 在线客服按钮样式 */
.customer-service-btn {
  position: fixed;
  right: 40rpx;
  bottom: 40rpx;
  width: 120rpx;
  height: 120rpx;
  border-radius: 50%;
  background-color: #ff6b6b;
  color: white;
  font-size: 24rpx;
  font-weight: bold;
  box-shadow: 0 4rpx 20rpx rgba(0, 0, 0, 0.2);
  z-index: 99;
  display: flex;
  align-items: center;
  justify-content: center;
}
</style>